
Ziua 1
Problema 1 (Explorarea planetei Marte)

    Intr-o viitoare misiune pe Marte, un modul planetar, continand mai multe 
Vehicule_de_Explorare_a_planetei_Marte (VEM), va fi asezat pe suprafata planetei. 
Fiecare VEM se va deplasa spre un transmitator care se afla pe planeta, la o 
anumita distanta de modul. In timp ce vehiculele se indreapta spre transmitator, 
ele vor colecta minerale (roci). O roca poate fi colectata o singura data, de 
primul VEM care ajunge la ea. Dupa colectarea acesteia, roca nu mai poate fi 
luata de alt VEM, dar alte VEM-uri pot trece prin aceasta pozitie.
VEM-urile nu se pot misca pe terenuri accidentate.
Conceptia constructiva a VEM-rilor este de asa natura incat ele se pot deplasa 
doar spre sud si spre est pentru a ajunge de la modul la transmitator. Mai multe 
VEM-uri pot ocupa aceeasi pozitie in acelasi moment.

Modul -> 0000000000   Linia 1
         0000011000   Linia 2
         0001020000   ....
         1101200001
         0100201100
         0101001100
         0120000100
         0000000000 <- Transmitator

Atentie: Daca un VEM nu ajunge la transmitator, rocile colectate de el sunt 
pierdute.
Problema:
Determinati miscarea fiecarui VEM pentru a obtine simultan un numar maxim de roci 
colectate si un numar maxim de VEM-uri care sa ajunga la transmitator. 
Intrare:
Suprafata planetei dintre modul si transmitator este reprezentata printr-un 
tablou de dimensiune PxQ cu modulul in pozitia (1, 1) si transmitatorul in 
pozitia (P, Q). Tipurile de teren sunt reprezentate astfel:
Teren plan:  0
Teren accidentat: 1
Roca: 2
Intrare:
Fisierul de intrare consta din:
NumberOfVehicles
P
Q
(X1 Y1) (X2 Y1) (X3 Y1)...(XP-1 Y1) (XP Y1)
(X1 Y2) (X2 Y2) (X3 Y2)...(XP-1 Y2) (XP Y2)
(X1 Y3) (X2 Y3) (X3 Y3)...(XP-1 Y3) (XP Y3)
..
(X1 YQ-1) (X2 YQ-1) (X3 YQ-1)...(XP-1 YQ-1) (XP YQ-1)
(X1 YQ) (X2 YQ) (X3 YQ)...(XP-1 YQ) (XP YQ)

P si Q sunt dimensiunile tabloului, iar NumberOfVehicles este un numar intreg 
mai mic decat 1000, reprezentand numarul de vehicule lansate de modul. 
Fiecare din cele Q linii reprezinta o linie de pe suprafata planetei. 
P si Q nu depasesc 128.
Exemplu:
MARS.DAT        Explicatii:
2           Numar de VEM-uri
10          P
8           Q
0 0 0 0 0 0 0 0 0 0 Linia  1
0 0 0 0 0 1 1 0 0 0 Linia  2
0 0 0 1 0 2 0 0 0 0 Linia  3
1 1 0 1 2 0 0 0 0 1 Linia  4
0 1 0 0 2 0 1 1 0 0 Linia  5
0 1 0 1 0 0 1 1 0 0 Linia  6
0 1 2 0 0 0 0 1 0 0 Linia  7
0 0 0 0 0 0 0 0 0 0 Linia  8
Iesire:
Iesirea este formata dintr-o secventa de linii reprezentand miscarile VEM-urilor 
catre transmitator. Fiecare linie contine numarul de identificare al VEM-ului, 
urmat de cifra 0 (pentru o deplasare spre SUD) sau 1 (pentru o deplasare spre EST).
Exemplu:
MARS.OUT    Explicatie:
1 1     vehiculul 1 se misca spre est
1 0     vehiculul 1 se misca spre sud
2 1     vehiculul 2 se misca spre est
2 0     vehiculul 2 se misca spre sud
1 1
..
1 1 
2 0 
2 1 
2 0 
2 0 
2 0 
2 0 
1 1 
1 0 
1 0 
1 0 
1 0 
1 0 
1 0 
2 0 
2 1 
1 1 
1 1 
1 1 
1 1 
1 1 
2 1 
2 1 
2 1 
2 1 
2 1 
2 1

2 VEM-uri si 3 roci ajung la transmitator obtinandu-se un scor de 5 puncte din 
5 posibile: deci 100%.
Atentie!!! Explicatia nu apare in fisierul de iesire.
Scorul:
Calculul scorului se bazeaza pe numarul de roci colectate, tinand cont si de 
numarul de VEM-uri ajunse la transmitator.
- O miscare interzisa invalideaza solutia si primeste 0 puncte. O miscare ilegala 
apare cand un VEM este mutat pe un teren accidentat sau in afara tabloului.
- Score = (numarul de roci colectate si aduse la transmitator + numarul de VEM-uri 
care ajung la transmitator - numarul de VEM-uri care nu ajung la transmitator) 
considerat ca  %  din scorul maxim posibil al solutiei corecte.
- Scorul nu poate depasi 100%; daca formula anterioara da o valoare negativa, 
se considera scorul de 0%.

=====================================

Ziua 1
Problema 2 (Jocul Hex)

    Scopul jocului este pentru primul jucator construirea unui lant intre 
coloanele 1 si N pe o tabla romboidala cu locatii hexagonale. 
Regulile jocului Hex:
Hex este un joc cu strategie jucat de doi parteneri pe o tabla romboidala NxN 
(1<=N<=20) cu locatii hexagonale; un exemplu pentru N=6 este dat in figura 
ce urmeaza
                             _
                           _/ \_
                         _/ \_/ \_
                       _/ \_/ \_/ \_
                     _/ \_/ \_/ \_/ \_
                   _/ \_/ \_/ \_/ \_/ \_
                 _/ \_/ \_/ \_/ \_/ \_/ \_
                  \_/ \_/ \_/ \_/ \_/ \_/
                    \_/ \_/ \_/ \_/ \_/
                      \_/ \_/ \_/ \_/
                        \_/ \_/ \_/ 
                          \_/ \_/
                            \_/

O linie este orientata SW-NE, iar o coloana este orientata SE-NW.
Cei doi parteneri ai jocului sunt programul tau si biblioteca de evaluare.
Programul tau face intotdeauna  prima miscare.
Partenerii aseaza alternativ piese pe tabla.
O piesa poate fi asezata pe orice pozitie libera de pe tabla.
Doua pozitii ale tablei sunt adiacente daca au o latura comuna.
Piesele unui partener asezate pe pozitii adiacente sunt legate.
Legarea este tranzitiva (si comutativa): daca hex1 este legat cu hex2 si hex2 
este legat cu hex3 atunci hex3 este legat cu hex1 si hex1 este legat cu hex3.

Problema:
Scrieti un program care joaca HEX.
Scopul primului jucator (programul tau) este de a lega o piesa de a ta de pe 
coloana 1 cu o piesa de-a ta de pe coloana N. 
Celalalt jucator (programul evaluatorului) incearca sa lege o piesa de-a lui de 
pe linia 1 cu o piesa de-a lui de pe linia N.
Daca programul tau joaca corect, va castiga (va realiza primul o legatura).
Intrare si iesire:
Programul tau nu foloseste nici un fisier pentru citire sau scriere; de asemenea 
nu va citi de la tastatura si nu va afisa nimic pe ecran. El va primi toate 
datele de intrare din biblioteca hex. Biblioteca va produce un fisier de iesire 
numit HEX.OUT; continutul sau se ignora de programul tau.

La inceputul jocului programul tau va avea acces la tabla de joc pe care pot fi 
deja plasate piese reprezentand o situatie in care primul jucator (programul tau) 
are strategie de castig. Programul tau trebuie sa foloseasca functiile GetMax si 
LookAtBoard pentru a determina situatia de pe tabla.
La inceputul jocului cei doi parteneri au cate un numar egal de piese pe tabla.
Restrictii:
Un joc este terminat complet in maxim 200 de mutari ale programului tau. 
Intregul joc trebuie terminat in maxim 40 secunde; se garanteaza ca biblioteca 
de evaluare isi termina partea sa de miscari in maxim 20 secunde.
Biblioteca:
O biblioteca numita HexLib este accesibila si trebuie folosita de programul tau. 
Un exemplu de fisier aratand cum se realizeaza legatura dintre biblioteca si 
program este inclus in directorul de lucru. 
Fisierele ei sunt TESTHEX.CPP, TESTHEX.C, TESTHEX.PAS si TESTHEX.BAS. 
Functiile din HexLib sunt: 

function LookAtBoard (row, column: integer): integer;
Returneaza 
 -1  daca row<1 sau row>N sau column<1 or column>N
  0  daca nu exista nici o piesa in acea pozitie
  1  daca piesa din pozitia specificata apartine  programului tau (jucatorul 1)
  2  daca piesa din pozitia specificata apartine bibliotecii de evaluare (jucatorul 2)

procedure PutHex (row, column: integer);
Plaseaza o piesa a ta in pozitia in pozitia specificata, daca aceasta este libera.

function GameIsOver: integer;
Returneaza unul din urmatoarele numere intregi:
0  daca jocul nu s-a terminat.
1  daca toate pozitiile de pe tabla sunt ocupate.
2  daca programul tau a castigat.
3  daca biblioteca de evaluare a castigat.

procedure MakeLibMove;
Permite bibliotecii de evaluare sa faca urmatoarea mutare. 
Schimbarea de pe tabla va fi indicata de LookAtBoard si celelalte functii.

function GetRow: integer;
Returneaza linia pe care se afla piesa pusa de biblioteca de evaluare sau -1 
daca nici o piesa nu a fost inca pusa. Aceasta functie returneaza intotdeauna 
aceeasi valoare pana la un nou apel al procedurii MakeLibMove.

function GetColumn: integer;
Returneaza coloana pe care se afla piesa pusa de biblioteca de evaluare sau -1 
daca nici o piesa nu a fost inca pusa. Aceasta functie returneaza intotdeauna 
aceeasi valoare pana la un nou apel al procedurii MakeLibMove.

function GetMax: integer;
Returneaza dimensiunea N a tablei de joc.
Scorul:
Daca programul tau castiga un joc, el va primi punctajul maxim al testului 
respectiv.
Daca programul tau pierde un joc el va primi 20% din punctajul testului respectiv.
Daca programul tau se termina inainte de sfarsitul jocului sau depaseste timpul 
reglementar, va primi 0 puncte.

========================================

Ziua 1
Problema 3 (Toxic iShongololo)

    In limba zulu, "iShongololo" este numele unei omizi. Aceste omizi au
multe picioare, sunt lungi si stralucitoare.
iShongololo se hranesc cu fruncte comestibile care in conditiile problemei pot
fi considerate ca paralelipipede solide cu dimensiunile intregi L (lungimea),
W (latimea) si H (inaltimea).
Problema:
    Scrieti un program care calculeaza numarul maxim de blocuri inghitite de
iShongololo fara ca sa fie violate restrictiile care urmeaza. Programul va scrie
in fisierul de iesire actiunile pe care le executa iShongololo in procesul de
consumare a fructului.
iShongololo pleaca din exteriorul fructului. Primul bloc care trebuie inghitit 
este (1,1,1). Dupa ce l-a inghitit, iShongololo trebuie sa treaca in acest bloc.
Restrictii:
1. iShongololo ocupa un singur bloc;
2. iShongololo inghite numai cate un bloc;
3. iShongololo nu poate vizita pozitiile in care a mai fost (prin urmare, nu 
poate reveni sau traversa urma sa);
4. iShongololo nu se poate deplasa intr-un bloc solid sau in exteriorul fructului;
5. iShongololo se poate deplasa si poate inghiti numai blocuri cu care are o fata
comuna. Ea poate inghiti numai blocuri care nu au alte fete comune cu blocurile
goale deja inghitite.
Intrare:
    Programul va citi din fisierul de intrare 3 numere intregi:
L (lungimea), W (latimea) si H (inaltimea) paralelipipedului.
Fiecare din numerele L,W,H ocupa cate o linie si poate lua valori in intervalul
[1,32].
Iesire:
    Fisierul de iesire contine mai multe linii. Fiecare linie incepe cu 'E'
(inghite) sau 'M' (mergi) urmata de 3 numere intregi ce reprezinta blocul care
va fi inghitit sau in care se va trece.
Exemplu:
Intrare:
2       Lungimea este 2
3       Latimea este 3
2       Inaltimea este 2
Iesire:
E 1 1 1
M 1 1 1
E 2 1 1
E 1 1 2
E 1 2 1
M 1 2 1
E 1 3 1
M 1 3 1
E 2 3 1
E 1 3 2
M 1 3 2

Scorul:
- Daca iShongololo violeaza restrictiile, solutia va apreziata cu 0 puncte;
- Numarul de puncte reprezinta in procente numarul de blocuri inghitite in
raport cu solutia optima gasita de autori;
- Solutia nu poate avea mai mult de 100%

=========================================

Ziua 2
Problema 4 (Recunoasterea caracterelor)
Problema cere sa scrieti un program care recunoaste caractere.
Detalii
Fiecare imagine a unui caracter ideal are dimensiunea 20 x 20. Fiecare element 
este '0' sau '1'. Pentru detalii vezi Figura 1a. 
Fisierul FONT.DAT contine reprezentarea a 27 imagini de caractere ideale in 
ordinea
    abcdefghijklmnopqrstuvwxyz
unde  reprezinta caracterul spatiu. 
Fisierul IMAGE.DAT contine una sau mai multe imagini de caractere "corupte" 
(cu greseli). O imagine caracter poate fi "corupta" intr-unul din urmatoarele moduri:
- cel mult o linie poate fi duplicata (si duplicarea se scrie pe linia imediat urmatoare)
- cel mult o linie poate lipsi
- unele '0'-uri pot fi schimbate in '1'
- unele '1'-uri pot fi schimbate in '0'
Nici o imagine de caracter nu poate sa aiba simultan o linie duplicata si o 
linie lipsa. Pot fi schimbate maxim 30% din '1'-rile si '0'-urile din orice 
imagine caracter din seturile de evaluare.

In cazul duplicarii unei linii, una sau ambele linii rezultate pot fi modificate
in mod independent.
Problema:
Scrieti un program care sa recunoasca o secventa de caractere in imaginile date 
de fisierul IMAGE.DAT folosind alfabetul de fonturi din fisierul FONT.DAT.
Recunoasterea unei imagini caracter se realizeaza alegand imaginea fontului 
caracter din care se obtine, printr-un numar minim de schimbari de '0' si '1' 
in varianta cea mai favorabila referitoare la linia duplicata sau stearsa. 
Toate caracterele din testele de evaluare folosite pot fi recunoscute de un 
program bine scris. Fiecare set de date conduce la o solutie corecta unica. 
Input:
Ambele fisiere de intrare incep cu un numar intreg N (19<=N<=1200) care specifica 
numarul de linii care urmeaza:
N
(cifra1) (cifra2) (cifra3) .. (cifra20)
(cifra1) (cifra2) (cifra3) .. (cifra20)
.
Fiecare linie de date contine 20 de cifre binare, fara spatii intre ele. 

Fisierul FONT.DAT descrie fonturile si are intotdeauna 541 linii. 
Atentie,  FONT.DAT poate diferi pentru fiecare set de intrare.
Output:
Programul trebuie sa construiasca un fisier IMAGE.OUT care contine, pe o singura 
linie, un sir ASCII cu caracterele recunoscute. Nu se foloseste nici un separator 
intre caractere. Daca programul nu recunoaste un caracter, va tipari '?' pe 
pozitia corespunzatoare. 
Scorul:
Scorul va fi calculat ca procent din caracterele corect recunoscute.
Exemplu:
Exemplu (incomplet) arata inceputul fisierului FONT.DAT (spatiu si 'a').
Exemplu IMAGE.DAT, reprezinta un 'a' corupt 
FONT.DAT    
540
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000011100000000000
00000111111011000000
00001111111001100000
00001110001100100000
00001100001100010000
00001100000100010000
00000100000100010000
00000010000000110000
00000001000001110000
00001111111111110000
00001111111111110000
00001111111111000000
00001000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000        Figura 1a   

IMAGE.DAT
19
00000000000000000000
00000000000000000000
00000000000000000000
00000011100000000000
00100111011011000000
00001111111001100000
00001110001100100000
00001100001100010000
00001100000100010000
00000100000100010000
00000010000000110000
00001111011111110000
00001111111111110000
00001111111111000000
00001000010000000000
00000000000000000000
00000000000001000000
00000000000000000000
00000000000000000000        Figura 1b

Exemplu output:
IMAGE.OUT
a

========================================

Ziua 2
Problema 5 (Stivuirea containerelor)

    Neptune Cargo Company gestioneaza o magazie de depozitare a containerelor.
Containerele sosesc la magazie pentru depozitare din ora in ora. Ele stau in 
depozit un numar (intreg pozitiv) de ore. Cand soseste un container, documentatia 
lui contine momentul (ora) in care acesta ar trebui scos din magazie. Primul 
container soseste la momentul 1. Momentul in care se cere scoaterea unui container 
poate precede sau succede momentul dat in documentatie, cu maxim 5 ore.  
In aceasta problema timpul este exprimat ca un intreg pozitiv din intervalul 
[1, 150].
O macara opereaza deasupra spatiului de stocare putand:
* aduce containere in magazie 
* scoate containere din magazie
* muta containerele dintr-un loc in altul
Problema:
Scrieti un program care sa ofere o strategie de intrare, stocare si scoatere a 
containerelor din magazie. Strategia este buna daca minimizeaza numarul total 
de miscari efectuate de macara. Magazia are forma unui paralelipiped cu 
dimensiunile X (lungime), Y (latime) si Z (inaltime). 
X,Y,Z sunt numere intregi si nu vor depasi valoarea 32.
Fiecare container este un cub 1x1x1. El poate fi stocat pe podea sau peste alt 
container. Macaraua poate muta doar containerul din varful unei astfel de stive. 
Mutarea unui container dintr-un loc in altul reprezinta o miscare a macaralei. 
Toate miscarile macaralei sunt instantanee si se fac intre intrari si iesiri ale 
containerelor. Cand magazia se umple, programul tau trebuie sa refuze intrarea 
altor containere. De asemenea programul tau poate fi mai putin eficient sau 
poate sa nu continue manevrarea containerelor atunci cand depozitul este aproape 
plin. Programul tau poate refuza intrarea de containere in orice moment. 
Input:
Programul tau trebuie sa interactioneze cu o biblioteca de simulare care va 
oferi date la care programul tau trebuie sa genereze actiuni si mesaje. La 
inceputul programului magazia este goala.
In timpul testarii programului, biblioteca va returna valori corecte pentru un 
set mic de date de test.
Fiecare container este identificat printr-un numar intreg pozitiv.
Programul tau poate apela urmatoarele functii: 

function GetX: integer; Returneaza lungimea magaziei;
function GetY: integer; Returneaza latimea magaziei;
function GetZ: integer; Returneaza inaltimea magaziei;

Urmatoarele functii ofera informatia referitoare la secventa de actiuni (intrarea 
si iesirea containerelor). Intrarile sunt facute la ora fixa, iar cererile de 
iesire sunt primite in interiorul unei ore. Deci, fiecare intrare marcheaza 
trecerea unei ore.
 
function GetNextContainer: integer;
Returneaza un numar intreg pozitiv reprezentand numarul containerului care va fi 
stocat sau scos. Daca nu mai sunt containere, returneaza valoarea 0, care indica 
terminarea programului tau, chiar daca in magazie mai exista, eventual, containere.
   
function GetNextAction: integer;
Returneaza un numar intreg reprezentand actiunea care trebuie facuta: 
1 - stocarea unui nou container
2 - iesirea unui container

 function GetNextStorageTime: integer;
Returneaza timpul, in ore (de la inceput) cand se preconizeaza iesirea unui 
container. Aceasta valoare foloseste in planificarea iesirilor programului tau; 
cererea reala de iesire poate fi facuta la un alt timp, care nu difera insa de 
cel preconizat cu mai mult de 5 ore. Aceasta functie da o valoare corecta doar 
in cazul cand GetNextAction returneaza valoarea 1. 

Ordinea in care sunt apelate aceste trei functii nu este importanta.
Apeluri consecutive ale functiilor GetNextContainer, GetNextAction, GetNextStorageTime 
vor returna intotdeauna informatii despre acelasi container, pana cand containerul 
este refuzat, stocat sau scos; din acel moment functiile vor returna informatie 
despre urmatorul container.
Output:
Odata ce programul tau a aflat informatia necesara despre urmatorul container, 
el va folosi urmatoarele functii pentru a manipula stocurile din magazie.

function MoveContainer(x1, y1, x2, y2: integer): integer;
Muta containerul din varful stivei de coordonate (x1, y1) in varful stivei de 
coordonate (x2, y2). 
Returneaza :
1  - daca actiunea este valida, 
0  - daca este imposibila (ilegala).
 
procedure RefuseContainer;
Refuza intrarea unui container

procedure StoreArrivingContainer(x, y: integer);
Stocheaza containerul intrat in varful stivei de coordonate (x, y).

procedure RemoveContainer(x, y: integer);
Scoate containerul din varful stivei de coordonate (x, y). Daca  programul tau 
nu poate efectua aceasta operatie, el trebuie sa se termine.

Miscarile ilegale sunt ignorate de biblioteca si nu au nici un efect in simularea 
sau calculul scorului.
Programul tau NU TREBUIE sa scrie nimic la iesire. 
Biblioteca cu care interactioneaza programul tau va crea un fisier de actiuni 
care este folosit pentru evaluare.
 
Ordinea de prelucrare a comenzilor:
Programul tau trebuie sa ia informatia referitoare la  urmatorul container. El 
trebuie apoi sa mute containere cu macaraua (daca este necesar) si, eventual, 
sa stocheze, scoata sau sa refuze actiunea solicitata. 
Biblioteca:
Programul tau va utiliza o biblioteca numita StackLib.

Un exemplu de fisier sursa este prezentat in directorul problemei; el este TESTSTK.PAS. 
Scorul:
Programul va fi testat cu mai multe seturi de date; pentru fiecare set, performanta sa este determinata in raport cu solutia comisiei, folosind urmatorii indicatori:
* numarul total de miscari ale macaralei dat de programul tau
* o penalitate de 5 miscari este data pentru fiecare container refuzat
* o penalitate de 5 miscari este data pentru fiecare container nestocat care trebuie scos (adica programul se termina normal inainte de realizarea completa a operatiei).
* Scorul total va fi calculat relativ la cea mai buna solutie cunoscuta.
* Daca programul face mai mult decat dublul numarului de operatii necesare, 
scorul este 0.
* Scorul minim este 0% iar scorul maxim este 100%.

=======================================

Ziua 2
Problema 6 (Etichetarea hartii)

Sunteti un asistent al cartografului si intilniti dificultati la scrierea pe 
harta a denumirilor de orase .
Harta reprezinta o retea de 1000x1000 de celule. Fiecare oras ocupa pe harta o 
singura celula. Denumirile de orase trebuie plasate pe harta in dreptunghiuri 
formate din celule. Aceste dreptunghiuri se numesc etichete.

    --------------------    ------------------
    |                   |   |                |
    --------------------     -----------------
                         
    --------------------    ------------------
    |                   |   |                |
    --------------------     -----------------

Fig. 1. Un oras cu patru pozitii posibile ale etichetei

Amplasarea etichetelor trebuie sa satisfaca urmatoarele restrictii:
- Eticheta orasului trebuie sa apara in una din cele patru pozitii in raport cu 
   orasul, conform figurii 1.
- Etichetele a doua orase nu trebuie sa se suprapuna.
- Orasele nu trebuie sa fie acoperite de alte etichete.
- Etichetele trebuie sa incapa pe harta.

Fiecare eticheta include denumirea completa a orasului plus un spatiu. Pentru 
fiecare denumire de oras se indica latimea si inaltimea literelor; spatiile au 
aceiasi dimensiune ca si literele.
 
    4  LanGa#
    3       
    2         Paarl#
    1       
    0 #Ceres
      0123456789

Fig.2. Fragment dintr-o harta

# reprezinta un spatiu 
 reprezinta pozitia orasului

Coloana din stanga hartii are coordonata orizontala 0, iar linia de jos a hartii 
are coordonata verticala 0. In figura 2 este prezentat fragmentul din coltul 
stanga jos al unei harti care include orasele Langa cu coordonatele (0,3), Ceres 
(6,1) si Paarl (7,3). Toate etichetele sunt amplasate corect, insa aceasta nu 
este singura amplasare corecta posibila.

Problema:
Programul tau trebuie sa citeasca coordonatele oraselor urmate de dimensiunile 
literelor si nume. In continuare programul trebuie sa plaseze pe harta cat mai 
multe etichete  posibile, fara sa violeze restrictiile de mai sus si sa scrie in 
fisierul de iesire coordonatele etichetelor plaste.

Intrare:
Prima linie a fisierului de intrare contine un numar intreg N (N<=1000) ce 
semnifica numarul de orase pe harta. Pentru fiecare oras fisierul contine o 
linie in care se indica:
- coordonata  orizontala (X); 
- coordonata verticala (Y);
- latimea (W); 
- inaltimea literelor (H) din denumirea orasului;
- numele propriu-zis.
Valorile X,Y,W si H sunt numere intregi. Numele orasului este format dintr-un 
singur cuvant lungimea caruia nu depaseste 200 de caractere. 
Exemplu de fisier de intrare:

MAPS.DAT        Explicatie
3           N=3
0 3 1 1 Langa       X=0, Y=3, W=1, H=1
6 1 1 1 Ceres
7 3 1 1 Paarl
Iesire :
Fisierul de iesire va avea N linii. Fiecare linie va contine coordonatele 
coltului stanga sus al etichetei orasului. Numerele vor fi separate printr-un 
singur spatiu. Daca programul tau nu poate plasa eticheta orasului, in fisierul 
de iesire se scrie
-1 -1
Informatia despre orase se scrie in ordinea in care a fost citita din fisierul 
de intrare. 
Exemplu de fisier de iesire:
MAPS.OUT        Explicatie:
1 4         Coordonatele etichetei "Langa "
0 0         Coordonatele etichetei "Ceres"
8 2         Coordonatele etichetei "Paarl"
Atentie : Explicatiile nu apar in fisierele 
MAPS.DAT si MAPS.OUT
Scorul:
Pentru fiecare test :
Scorul se calculeaza  ca raportul dintre numarul de denumiri de orase plasate 
si solutia cunoscuta autorilor.
Scorul minim este 0%, iar cel maxim 100%.
Daca cel putin o eticheta violeaza restrictiile, scorul va fi 0.
Daca cel putin o eticheta nu indica orasul specificat, scorul va fi 0.

=========================================================
